/**    
 * 文件名：JsonObjectUtils.java</br>
 *    
 * 版本信息：v1.0</br>
 * 日期：2017年6月27日</br>
 * © 2005-2017 雷技信息科技（上海）有限公司版权所有</br>
 *
 */
package com.logic.landseaserver.common.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
import com.logic.landseaserver.common.LandseaErrorMessageEnum;
import com.logic.landseaserver.common.exception.LandseaException;
import com.logic.landseaserver.common.exception.ResultCodes.CommonResultCode;

/**
 *
 * 项目名称：system-server</br>
 * 类名称：JsonObjectUtils</br>
 * 类描述：json相关工具类，提供json和对象互相转换</br>
 * 创建人：Aaron</br>
 * 创建时间：2017年6月27日 下午2:01:26</br>
 * 
 * @version 1.0
 *
 */
public abstract class JsonObjectUtils
{
    private static final Logger LOGGER = LoggerFactory.getLogger(JsonObjectUtils.class);
    
    /**
     * 
     * [简要描述]：将map转换成JsonObject</br>
     * [详细描述]：支持Map为复合结构</br>
     * [作者]：Aaron(2017-06-27)</br>
     *
     * @param map 待转换的Map
     * @return JsonObject 转换后的Json对象
     * @throws LandseaException 当解析json失败时抛出该异常
     *
     */
    public static JsonObject map2JsonObject(Map<String, Object> map)
        throws LandseaException
    {
        JsonObject resultJson = new JsonObject();
        
        if (MapUtils.isEmpty(map))
        {
            return resultJson;
        }
        
        Gson gson = new Gson();
        
        try
        {
            String tempStr = gson.toJson(map);
            JsonParser jsonParser = new JsonParser();
            JsonElement jsonElement = jsonParser.parse(tempStr);
            return jsonElement.getAsJsonObject();
        }
        catch (Exception e)
        {
            LOGGER.error("JsonObjectUtils|Map convert to jsonObject failed.", e);
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
    
    /**
     * 
     * [简要描述]：将map转换成JsonObject</br>
     * [详细描述]：支持Map为复合结构</br>
     * [作者]：Aaron(2017-06-27)</br>
     *
     * @param map 待转换的Map
     * @return String json字符串
     * @throws LandseaException 当解析json失败时抛出该异常
     *
     */
    public static String map2JsonStr(Map<String, Object> map)
        throws LandseaException
    {
        if (MapUtils.isEmpty(map))
        {
            return "";
        }
        
        Gson gson = new Gson();
        
        try
        {
            String tempStr = gson.toJson(map);
            return tempStr;
        }
        catch (Exception e)
        {
            LOGGER.error("JsonObjectUtils|Map convert to jsonObject failed.", e);
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
    
    /**
     * 
     * [简要描述]：将json字符串转换成JsonElement</br>
     * [详细描述]：字符串必须为标准的json字符串，可传json数组</br>
     * [作者]：Aaron(2017-06-27)</br>
     *
     * @param jsonStr json字符串
     * @return JsonElement 转化后的Json对象，有可能是JsonObject或JsonArray
     * @throws LandseaException 当解析json失败时抛出该异常
     *
     */
    public static JsonElement string2JsonObject(String jsonStr)
        throws LandseaException
    {
        if (StringUtils.isEmpty(jsonStr))
        {
            return new JsonObject();
        }
        try
        {
            JsonParser jsonParser = new JsonParser();
            return jsonParser.parse(jsonStr);
        }
        catch (Exception e)
        {
            LOGGER.error("JsonObjectUtils|String convert to jsonObject failed.", e);
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
    
    /**
     * 
     * [简要描述]：将Json字符串转换成Map</br>
     * [详细描述]：支持复合Map</br>
     * [作者]：Aaron(2017-06-27)</br>
     *
     * @param jsonStr json字符串
     * @return Map<String,Object> 其中Object可以是map
     * @throws LandseaException 当解析json失败时抛出该异常
     *
     */
    @SuppressWarnings("unchecked")
    public static Map<String,Object> jsonStr2map(String jsonStr)
        throws LandseaException
    {
        Map<String, Object> map = new HashMap<String, Object>();
        if (StringUtils.isEmpty(jsonStr))
        {
            return map;
        }
        
        try
        {
            return JSON.parseObject(jsonStr, Map.class);
        }
        catch (Exception e)
        {
            LOGGER.error("JsonObjectUtils|JsonString convert to Map failed.", e);
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
    /**
     * 
     * [简要描述]：将Json字符串转换成Bean</br>
     * [详细描述]：</br>
     * [作者]：Aaron(2017-06-27)</br>
     *
     * @param jsonStr json字符串
     * @return bean对象
     * @throws LandseaException 当解析json失败时抛出该异常
     *
     */
    public static <T> T jsonStr2Bean(String jsonStr, Class<T> type)
        throws LandseaException
    {
        try
        {
            if ((StringUtils.isEmpty(jsonStr)))
            {
                return type.newInstance();
            }
            JsonParser jp = new JsonParser();
            JsonElement je = jp.parse(jsonStr);
            Gson gson = new Gson();
            return gson.fromJson(je, type);
        }
        catch (Exception e)
        {
            LOGGER.error("JsonObjectUtils|JsonString convert to Object failed.", e);
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
    
    /**
     * 
     * [简要描述]：对象转jsonObject</br>
     * [详细描述]：</br>
     * [作者]：Aaron(2017-07-24)</br>
     *
     * @param object
     * @return
     * @throws LandseaException
     *
     */
    public static JsonObject bean2JsonObject(Object object) throws LandseaException
    {
        if (null == object)
        {
            return new JsonObject();
        }
        Gson gson = new Gson();
        try
        {
            String tempStr = gson.toJson(object);
            JsonParser jsonParser = new JsonParser();
            JsonElement jsonElement = jsonParser.parse(tempStr);
            return jsonElement.getAsJsonObject();
        }
        catch (Exception e)
        {
            LOGGER.error("JsonObjectUtils|Object convert to jsonObject failed.", e);
            throw LandseaException.createException(CommonResultCode.E00040001, e);
        }
    }
	
	    /**
     * 
     * [简要描述]：JSON字符串转换成List<Object>
     * [详细描述]：    
     *
     * @param paramString
     * @param type
     * @return
     * @throws MineException
     */
    public static <T> List<T> jsonStr2ListBean(String paramString, Class<T> type) throws LandseaException
    {
        try
        {
            JsonParser jp = new JsonParser();
            JsonElement je = jp.parse(paramString);
            JsonArray array = je.getAsJsonArray();
            
            return jsonArray2ListBean(array, type);
        }
        catch (JsonSyntaxException e)
        {
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
    
    public static <T> List<T> jsonArray2ListBean(JsonArray jsonArray, Class<T> type) throws LandseaException
    {
        try
        {
            Gson gson = new Gson();
            if (null == jsonArray)
            {
                return new ArrayList<T>();
            }
            
            List<T> resultList = new ArrayList<T>();
            
            for (JsonElement element : jsonArray)
            {
                resultList.add(gson.fromJson(element, type));
            }
            
            return resultList;
        }
        catch (Exception e)
        {
            throw LandseaException.createException(LandseaErrorMessageEnum.COMMON_PARESE_JSON_ERROR, e);
        }
    }
}
